package com.pince.lifcycleliveav.pullPalyer

import android.content.Context
import android.os.Bundle
import android.util.AttributeSet
import android.util.Log
import android.view.Gravity
import android.view.Surface
import android.view.ViewGroup
import android.widget.FrameLayout
import com.pince.lifcycleliveav.em.PlayAutoAdjust
import com.pince.lifcycleliveav.em.RENDER_ROTATION_PORTRAIT
import com.tencent.rtmp.ITXLivePlayListener
import com.tencent.rtmp.TXLivePlayConfig
import com.tencent.rtmp.TXLivePlayer
import com.tencent.rtmp.TXLivePlayer.*
import com.tencent.rtmp.ui.TXCloudVideoView
import java.util.*


/**
 * 将腾讯直播控件封装一遍　并暴露自己定义的接口给外界调用
 */
open class TXLivePlayerExt : FrameLayout, ILivePlayer {
    private val TAG = "TXPlayer"

    /**
     * 控制器
     */
    private var mControllers = ArrayList<IPullPlayController>()

    /**
     * 播放器
     */
    lateinit var mTxLivePlayer: TXLivePlayer

    /**
     * 设置播放模式，自动，流畅，极速
     */
    var playAutoAdjust = PlayAutoAdjust.QuicknessMODEL

    /**
     * 视频重连次数
     */
    var connectRetryCount = 5

    /**
     * 设置重连间隔时间
     */
    var connectRetryInterval = 3

    /**
     * 承接的界面
     */
    private var mTxCloudVideoView: TXCloudVideoView ?= null

    private var params2: LayoutParams = LayoutParams(
            ViewGroup.LayoutParams.MATCH_PARENT,
            ViewGroup.LayoutParams.MATCH_PARENT,
            Gravity.CENTER)

    //构造函数
    constructor(context: Context) : super(context)

    constructor(context: Context, mAttributeSet: AttributeSet?) : super(context, mAttributeSet)

    init {
        initLivePlayer()
    }

    /**
     * 初始化播放器
     * 1.初始化TxLivePlayer
     * 2.设置渲染角度
     * 3.设置播放监听器
     *   通过mControllers分发到设置监听地方
     *
     *   2020.6.28修改 播放view 只需要在初始化的时候添加一次，并绑定在TXLivePlayer上一次就可以了。会加快拉流的速度
     */
    private fun initLivePlayer() {
        mTxLivePlayer = TXLivePlayer(context)
        mTxLivePlayer.setRenderRotation(RENDER_ROTATION_PORTRAIT)//设置渲染角度
        mTxLivePlayer.setPlayListener(object : ITXLivePlayListener {
            override fun onPlayEvent(event: Int, bundle: Bundle?) {
                mControllers.forEach {
                    it.onPlayEvent(event, bundle)
                }
            }

            override fun onNetStatus(bundle: Bundle) {
                mControllers.forEach {
                    it.onNetStatus(bundle)
                }
            }
        })
    }


    /**
     * 添加播放控制器controllers
     */
    override fun addController(ctroller: IPullPlayController) {
        mControllers.add(ctroller)
        ctroller.attachPlayer(this)
    }


    /**
     * 释放控制器
     */
    override fun clearController() {
        mControllers.clear()
    }

    /**
     * 播放器暂停
     *  1.通知控制器播放器已经暂停
     */
    override fun pause() {
        mTxLivePlayer.pause()
        mControllers.forEach {
            it.onPlayEvent(PLAY_EVT_ON_PAUSE, null)
        }

    }

    /**
     * 播放器重新开始播放
     *  1.通知控制器播放器重新开始播放
     */
    override fun resume() {
        mTxLivePlayer.resume()
        mControllers.forEach {
            it.onPlayEvent(PLAY_EVT_ON_RESUME, null)
        }
    }

    /**
     * 开始播放 @param uri 播放地址 FLV 直播流：PLAY_TYPE_LIVE_FLV。
     * 自动根据连接带有的协议走不同的同道，适用于直播
     */
    override fun startPlay(uri: String): Int {
        if (uri.contains(".flv")) {//直播模式flv
            return startPlay(uri, PLAY_TYPE_LIVE_FLV)
        } else if (uri.startsWith("rtmp://")) {//直播RTMP
            return startPlay(uri, PLAY_TYPE_LIVE_RTMP)
        }
        return startPlay(uri, PLAY_TYPE_VOD_FLV)
    }

    /**
     * 播放rtmp流 低延迟流
     * @see startPlay(url:String)
     * 1.添加播放RTMP模式，RTMP 加速流，用于连麦：PLAY_TYPE_LIVE_RTMP_ACC。
     */
    override fun startPlayRtmp(uri: String?): Int {
        return startPlay(uri, PLAY_TYPE_LIVE_RTMP_ACC)
    }

    /**
     * 开始播放
     * @param uri 播放地址
     * @param int TXLivePlayer.PLAY_TYPE_LIVE_FLV
     * 1.播放器开始前先释放下播放器和手动消耗
     * 2.清理掉所有已经添加view
     * 3.重新添加播放器
     * 4.设置播放模式并开始播放，返回领表示成功
     */
    override fun startPlay(uri: String?, int: Int): Int {
        uri?.let {
            mTxCloudVideoView?.stop(true)
            mTxCloudVideoView?.onDestroy()
            mTxCloudVideoView?.clearLastFrame(true)
            this.removeAllViews()
            mTxCloudVideoView = TXCloudVideoView(context)
            this.addView(mTxCloudVideoView, params2)
            mTxLivePlayer.stopPlay(true)
            mTxLivePlayer.setPlayerView(mTxCloudVideoView)
            return mTxLivePlayer.startPlay(it, int)
        }
        return -1
    }


    /**
     * 停止播放 是否清除最后帧
     */
    override fun stopPlay(isNeedClearLastImg: Boolean) {
        mTxLivePlayer.setPlayerView(null)
        //mTxLivePlayer.setPlayListener(null)
        mTxLivePlayer.stopRecord()
        mTxLivePlayer.stopPlay(isNeedClearLastImg)
        mTxCloudVideoView?.stop(true)
        mTxCloudVideoView?.onDestroy()
        mTxCloudVideoView?.clearLastFrame(true)
        this.removeAllViews()
    }

    /**
     * 播放器配置
     * 1.设置是否自动调整缓存时间
     * 2.设置最小的缓存时间。
     * 3.设置最大的缓存时间。
     * 4.设置播放器重连次数。
     * 5.设置回声消除。。
     *
     */
    override fun setTXLivePlayConfig(enableAEC: Boolean) {
        val mPlayConfig = TXLivePlayConfig()
        when (playAutoAdjust) {
            PlayAutoAdjust.QuicknessMODEL -> {
                mPlayConfig.setAutoAdjustCacheTime(true)
                mPlayConfig.setMinAutoAdjustCacheTime(1f)
                mPlayConfig.setMaxAutoAdjustCacheTime(1f)
            }
            PlayAutoAdjust.FluencyMODEL -> {
                mPlayConfig.setAutoAdjustCacheTime(false)
                mPlayConfig.setMinAutoAdjustCacheTime(5f)
                mPlayConfig.setMaxAutoAdjustCacheTime(5f)
            }

            PlayAutoAdjust.AutoMDOEL -> {
                mPlayConfig.setAutoAdjustCacheTime(true)
                mPlayConfig.setMinAutoAdjustCacheTime(1f)
                mPlayConfig.setMaxAutoAdjustCacheTime(5f)
            }
        }
        Log.e(TAG, "当前播放模式：$playAutoAdjust")
        mPlayConfig.setConnectRetryCount(connectRetryCount)
        mPlayConfig.setConnectRetryInterval(connectRetryInterval)
        mPlayConfig.setEnableMessage(true)
        mPlayConfig.enableAEC(enableAEC)
        mTxLivePlayer.setConfig(mPlayConfig)
    }


    /**
     * 1.释放控制器
     * 2.停止播放器
     */
    override fun destroy() {
        mControllers.clear()
        stopPlay(true)
    }

    /**
     * 是否在播播放中
     */
    override fun isPlaying(): Boolean {
        return mTxLivePlayer.isPlaying
    }

    override fun setSurface(surface: Surface) {
        mTxLivePlayer?.setSurface(surface)
    }

    override fun enableHardwareDecode(enable: Boolean) {
        mTxLivePlayer?.enableHardwareDecode(enable)
    }

    //设置是否静音
    override fun setMute(mute: Boolean) {
        mTxLivePlayer?.setMute(mute)
    }

    //设置声音播放模式
    override fun setAudioRoute(audioRoute: Int) {
        mTxLivePlayer?.setAudioRoute(audioRoute)
    }

    /**
     * 设置播放声音回调
     * void onAudioVolumeEvaluationNotify(int volume)
     * volume	int	音量大小, 取值范围 [0，100]。
     */
    override fun setAudioVolumeEvaluationListener(listener: ITXAudioVolumeEvaluationListener) {
        enableAudioVolumeEvaluation(300)
        mTxLivePlayer?.setAudioVolumeEvaluationListener(listener)
    }

    /**
     * 启用音量大小评估。
     * intervalMs 决定了 onAudioVolumeEvaluationNotify 回调的触发间隔，单位为ms，最小间隔为 100ms，如果小于等于 0 则会关闭回调，建议设置为 300ms。
     */
    override fun enableAudioVolumeEvaluation(intervalMs: Int) {
        mTxLivePlayer?.enableAudioVolumeEvaluation(intervalMs)
    }

    override fun setRenderMode(mode: Int) {
        mTxLivePlayer?.setRenderMode(mode)
    }

    override fun snapshot(listener: ITXSnapshotListener) {
        mTxLivePlayer?.snapshot(listener)
    }
}